\chapter{\texttt{std::launder()}}\label{ch32}
有一个叫\texttt{std::launder()}的新的库函数，就我了解和看到的，它是一个解决核心问题的方法，
然而，它其实并没有什么用。


\section{\texttt{std::launder()}的动机}
根据当前的标准，下面的代码会导致未定义行为：
\begin{lstlisting}
    struct X {
        const int n;
        double d;
    };
    X* p = new X{7, 8.8};
    new (p) X{42, 9.9};     // 请求把一个新的值放进p处
    int i = p->n;           // 未定义行为（i可能是7也可能是42）
    auto d = p->d;          // 也是未定义行为（d可能是8.8也可能是9.9）
\end{lstlisting}
原因是在当前的内存模型中，C++标准中的\texttt{[basic.life]}这一节中，粗略的讲到：

\begin{quote}
    如果，\ldots，一个新的对象在一个已经被原本对象占据的位置处创建，
    \begin{itemize}
        \item 一个指向原本的对象的指针，
        \item 一个引用原本对象的引用，
        \item 原本对象的名称
    \end{itemize}
    将会自动指向新的对象\ldots 如果：
    \footnote{译者注：因为英语喜欢把if放在后边，所以此处的“如果”是前边的结果的条件。}
    \begin{itemize}
        \item 原本对象的类型没有\texttt{const}修饰，并且如果是类类型的话还要
        不包含\texttt{const}修饰的或者引用类型的非静态数据成员。
        \item \ldots
    \end{itemize}
\end{quote}
这个行为并不是新定义的。它在C++03中就被指明，目的是为了允许几项编译器优化
（包括使用虚函数时的相似优化）。

按照标准中的说法，当对象中有常量或者引用类型的成员时，我们必须保证每次访问内存时
都使用placement new返回的值：
\begin{lstlisting}
    struct X {
        const int n;
        double d;
    };
    X* p = new X{7, 8.8};
    p = new (p) X{42, 9.9}; // 注意：把placement new的返回值赋给p
    int i = p->n;           // OK，i现在保证是42
    auto d = p->d;          // OK，d现在保证是9.9
\end{lstlisting}
不幸的是，这个规则很少有人知道或者用到。更糟的是，在实践中，
有时候并不能这么简单的使用placement new的返回值。你可能需要额外的对象，
而且当前的迭代器接口也不支持它。

使用返回值可能会导致开销的一个例子是存储的位置已经有
成员存在。\nameref{ch15}和\\\nameref{ch16}就是这种情况。

这里有一个简化的例子实现了类似于\texttt{std::optional}的类：
\begin{lstlisting}
    template<typename T>
    class optional
    {
    private:
        T payload;
    public:
        optional(const T& t) : payload(t) {
        }

        template<typename... Args>
        void emplace(Args&&... args) {
            payload.~T();
            ::new (&payload) T(std::forward<Args>(args)...); // *
        }

        const T& operator*() const & {
            return payload; // OOPS：返回没有重新初始化的payload
        }
    };
\end{lstlisting}
如果这里\texttt{T}是一个带有常量或者引用成员的结构体：
\begin{lstlisting}
    struct X {
        const int _i;
        X(int i) : _i(i) {}
        friend std::ostream& operator<< (std::ostream& os, const X& x) {
            return os << x._i;
        }
    };
\end{lstlisting}
那么下面的代码将导致未定义行为：
\begin{lstlisting}
    optional<X> optStr{42};
    optStr.emplace(77);
    std::cout << *optStr;   // 未定义行为（可能是42也可能是77）
\end{lstlisting}
这是因为输出操作之前调用了\texttt{operator*}，它会返回\texttt{payload}，
而placement new（在\texttt{emplace()}调用中）在\texttt{payload}处放置了
一个新的值却没有使用返回值。

在一个类似这样的类中，你需要添加一个额外的指针成员来存储placement new的返回值，
并在需要时使用它：
\begin{lstlisting}
    template<typename T>
    class optional
    {
    private:
        T payload;
        T* p;   // 为了能使用placement new的返回值
    public:
        optional(const T& t) : payload(t) {
            p = &payload;
        }

        template<typename... Args>
        void emplace(Args&&... args) {
            payload.~T();
            p = ::new (&payload) T(std::forward<Args>(args)...);
        }

        const T& operator*() const & {
            return *p;  // 这里不要使用payload！
        }
    };
\end{lstlisting}
基于分配器的容器例如\texttt{std::vector}等也有类似的问题。
因为它们在内部通过分配器使用placement new。
例如，一个类似于\texttt{vector}的类的粗略实现如下：
\begin{lstlisting}
    template<typename T, typename A = std::allocator<T>>
    class vector
    {
    public:
        typedef typename std::allocator_traits<A> ATR;
        typedef typename ATR::pointer pointer;
    private:
        A _alloc;       // 当前分配器
        pointer _elems; // 元素的数组
        size_t _size;   // 元素的数量
        size_t _capa;   // 容量
    public:
        void push_back(const T& t) {
            if (_capa == _size) {
                reserve((_capa+1)*2);
            }
            ATR::construct(_alloc, _elems+_size, t);    // 调用placement new
            ++_size;
        }

        T& operator[] (size_t i) {
            return _elems[i];   // 对于被替换的有常量成员的元素将是未定义行为
        }
    };
\end{lstlisting}
再一次，注意\texttt{ATR::construct()}并没有返回调用placement new的返回值。
因此，我们不能使用这个返回值来代替\texttt{\_elems}。

注意只有C++11之后这才会导致问题。在C++11之前，
使用有常量成员的元素既不可能也没有正式的支持，因为元素必须能拷贝构造并且可赋值
（尽管基于节点的容器例如链表对有常量成员的元素能完美工作）。然而，C++11引入了移动语义之后，
就可以支持带有常量成员的元素了，例如上边的类\texttt{X}，然后也导致了上述的未定义行为。

\texttt{std::launder()}被引入就是为了解决这些问题。
然而，正如我之前所说的一样，事实上使用\texttt{std::\\
launder()}完全不能解决vector的问题。


\section{\texttt{launder()}如何解决问题}
C++标准委员会的核心工作组决定通过引入\texttt{std::launder()}来解决这个问题
（见\url{https://wg21.link/cwg1776}）：
如果你有一个因为底层内存被替换而导致访问它变成未定义行为的指针：
\begin{lstlisting}
    struct X {
        const int n;
        double d;
    };
    X* p = new X{7, 8.8};
    new (p) X{42, 9.9};     // 请求把一个新的值放进p处
    int i = p->n;           // 未定义行为（i可能是7也可能是42）
    auto d = p->d;          // 也是未定义行为（d可能是8.8也可能是9.9）
\end{lstlisting}
任何时候你都可以调用\texttt{std::launder()}来确保底层内存被重新求值：
\begin{lstlisting}
    int i = std::launder(p)->n;     // OK，i是42
    auto d = std::launder(p)->d;    // OK，d是9.9
\end{lstlisting}
注意\texttt{launder()}并不能解决使用\texttt{p}时的问题，
它只是解决了使用它的那些表达式的问题：
\begin{lstlisting}
    int i2 = p->n;          // 仍然是未定义行为
\end{lstlisting}
任何时候你想访问替换之后的值都必须使用\texttt{std::launder()}。

这可以在如下类似于\texttt{optional}的类中工作：
\begin{lstlisting}
    template<typename T>
    class optional
    {
    private:
        T payload;
    public:
        optional(const T& t) : payload(t) {
        }

        template<typename... Args>
        void emplace(Args&&... args) {
            payload.~T();
            ::new (&payload) T(std::forward<Args>(args)...);    // *
        }

        const T& operator*() const & {
            return *(std::launder(&payload));   // OK
        }
    };
\end{lstlisting}
注意我们必须确保每一次对\texttt{payload}的访问都要像这里的\texttt{operator*}中一样
经过\texttt{std::launder()}的“粉刷(whitewashing)”。


\section{为什么/什么时候\texttt{launder()}不生效}
然而，对于像vector这种基于分配器的容器，之前的解决方案并没有效果。
这是因为如果我们尝试类似这样做：
\begin{lstlisting}
    template<typename T, typename A = std::allocator<T>>
    class vector
    {
    public:
        typedef typename std::allocator_traits<A> ATR;
        typedef typename ATR::pointer pointer;
    private:
        A _alloc;       // 当前分配器
        pointer _elems; // 元素的数组
        size_t _size;   // 元素的数量
        size_t _capa;   // 容量
    public:
        void push_back(const T& t) {
            if (_capa == _size) {
                reserve((_capa+1)*2);
            }
            ATR::construct(_alloc, _elems+_size, t);    // 调用placement new
            ++_size;
        }

        T& operator[] (size_t i) {
            return std::launder(_elems)[i]; // OOPS：仍然是未定义行为
        }
        ...
    };
\end{lstlisting}
在\texttt{operator[]}中的\texttt{launder()}并没有作用，因为\texttt{pointer}可能是
个智能指针（即是类类型），而对于它们\texttt{launder()}没有作用。
\footnote{感谢Jonathan Wakely指出这一点。}

如果尝试：
\begin{lstlisting}
    std::launder(this)->_elems[i];
\end{lstlisting}
也没有用，因为\texttt{launder()}只对生命周期已经结束的对象的指针才有用。
\footnote{感谢Richard Smith指出这一点。}

因此，\texttt{std::launder()}并不能有助于解决基于分配器的容器中元素含有
常量/引用成员导致未定义行为的问题。
看起来一个通用的核心修复是很必要的（参见我的文章\url{https://wg21.link/p0532}）。


\section{后记}
\texttt{std:launder()}作为国家机构对C++14的一个注释引入
（见\url{https://wg21.link/n3903}，它最早作为核心工作组的issue 1776进行讨论
（见\url{https://wg21.link/cwg1776}）。
之后它由Richard Smith和Hubert Tong在\url{https://wg21.link/n4303}中首次提出。
最终被接受的是Richard Smith发表于\url{https://wg21.link/p0137r1}的提案。